#ifndef _PROTOCOLMGR_H_
#define _PROTOCOLMGR_H_

#include "Common.h"
#include "String.h"
#include "Resource.h"
#include "GameDataEnum.h"
#include "GameStruct.h"
#include "WorldPacket.h"
#include "ItemManager.h"
#include "PubDataManager.h"
#include "CenterFriendManager.h"
#include "CenterBattleManager.h"
#include "CenterBattleLogManager.h"
#include "CenterJudgeManager.h"
#include "CenterClubManager.h"
#include "MJEnum.h"
#include "PKStruct.h"
#include "json/json.h"
#include "GameDefine.h"

//#ifdef CENTERMATCH
//struct CenterMatch;
//struct CenterMatchChannelInfo;
//struct CenterMatchPlayer;
//struct CenterMatchPlayerInfo;
//#endif // CENTERMATCH

#ifdef CENTERMATCH
	//#include "CenterMatchManager.h"
	#include "CenterMatchLogic.h"
	struct stMatchZone;
#endif // CENTERMATCH

class  CharPtr;
class  ItemPtr;
class  ChannelPtr;
class  EffectPtr;
class  Channel;
class  UserPtr;
class  TownPtr;
class  MailPtr;
class  MissionPtr;
struct tagWeaveItem;
struct MaJonMission;
struct MJBaseTablePlayer;
struct MJScoreChange;
struct MJConstantlyCale;


struct game_server_tag_;
typedef struct game_server_tag_ GameServer;

struct game_goods_tag_;
typedef struct game_goods_tag_ GameGoods;

struct game_mail_tag_;
typedef struct game_mail_tag_ GameMail;

struct game_bank_tag_;
typedef struct game_bank_tag_ GameBank;

struct game_march_tag_;
typedef game_march_tag_ GameMarch;

struct game_pubdata_tag_;
typedef game_pubdata_tag_ GamePubData;

struct stCenterBattleOpenCoins;

struct GCPlayer;
struct GZIDInfo;
struct stCommonSign;


struct CMD_SendCard;
struct CMD_GameStart;
struct CMD_OperateNotify;
// 活动信息
struct ActiveInfo
{
	uint32 destId;
	uint32 type;
	uint32 data1;
	uint32 data2;
	uint32 data3;
	uint32 data4;
	String sdata1;
	ActiveInfo():destId(0),type(0),data1(0),data2(0),data3(0),data4(0){}
};

class ProtocolsManager
{
public:	
	virtual ~ProtocolsManager(void){};


	//创建PONG包
	virtual bool	CreatePongPacket(WorldPacket * packet, const uint32	serial);
	// 登录结果包
	virtual bool CreateUserLoginPacket(WorldPacket * packet, const uint8 status);
	/**
	 * @创建时间 2011-08-31
	 * @创建人 李志勇
	 * @函数作用 创建进房结果封包
	 * @参数
	 * 	@serial 房间ID号
	 *  @status 结果
	 */
	virtual bool CreateEnterTownPacket(WorldPacket * packet, const uint32 serial, const uint8 status);
	virtual bool CreateCommonGoHallOrTablePacket(WorldPacket * packet, const uint32 where = 0);
	/**
	 * @创建时间 2011-10-18
	 * @创建人 李志勇
	 * @函数作用 元宝更新
	 * @参数
	 * 	@golds 当前元宝
	 */
	virtual bool CreateGoldsUpdatePacket(WorldPacket * packet, const uint32 golds);
	/**
	 * @创建时间 2011-11-14
	 * @创建人 李志勇
	 * @函数作用 返回大厅界面
	 * @参数
	 * 	@isOffline 是否断线
	 */
	virtual bool CreateExitReturnHallPacket(WorldPacket * packet, const uint8 isOffline = 1);
	/**
	 * @创建时间 2011-09-07
	 * @创建人 李志勇
	 * @函数作用 活动信息
	 * @参数
	 *  @info 活动信息数据
	 */
	virtual bool CreateActiveInfoPacket(WorldPacket * packet, ActiveInfo &info);

	/**
	 * @创建时间 2011-09-07
	 * @创建人 李志勇
	 * @函数作用 消息
	 * @参数
	 *  @content 消息内容
	 *
	 * @修改时间 2011-11-2
	 * @修改人 李志勇
	 * @修改内容：添加参数
	 * @参数
	 *  @type 消息类型(1：公告，2：一般信息，3：弹框消息)
	 */
	virtual bool CreateLocalMessagePacket(WorldPacket * packet, const String &content, const uint8 type = 1);
	/**
	 * @创建时间 2011-09-23
	 * @创建人 李志勇
	 * @函数作用 打开背包
	 * @参数
	 *  @pChr 角色
	 */
	virtual bool CreateOpenBackpackPacket(WorldPacket * packet, CharPtr &pChr);
	/**
	 * @创建时间 2011-09-23
	 * @创建人 Roach
	 * @函数作用 特殊背包 SMSG_EXCHANGEBAG = 0x002C
	 * @参数
	 *  @pChr 角色
	 */
	virtual bool CreateExchangeBagPacket(WorldPacket * packet, CharPtr &pChr);
	// SMSG_UPDATEEXCHANGEITEMNUMBER = 0x0035, // 更新兑换背包道具数量
	virtual bool CreateUpdateExchangeItemNumberPacket(WorldPacket * packet, const uint32 & item_id, const uint32 & model_id, const uint32 number, bool bDelete = false);
	/**
	 * @创建时间 2011-10-17
	 * @创建人 李志勇
	 * @函数作用 更新物品数量
	 * @参数
	 * 	@itemModelId 物品模式ID
	 *  @number	物品数量
	 */
	virtual bool CreateUpdateItemNumberPacket(WorldPacket * packet,  const uint32 itemModelId, const uint32 number);
	/**
	 * @创建时间 2011-10-17
	 * @创建人 李志勇
	 * @函数作用 添加新物品
	 * @参数
	 * 	@itemPtr 物品
	 */
	virtual bool CreateAddNewItemPacket(WorldPacket * packet, ItemPtr &itemPtr);
	/**
	 * @创建时间 2011-10-17
	 * @创建人 李志勇
	 * @函数作用 获取商城物品列表
	 * @参数
	 *  @shopType 商城类型
	 * 	@labelType 商城分类类型
	 *  @allPage 总页数
	 *  @curPage 当前页
	 *  @lstGameGoods 商品列表
	 */
	virtual bool CreateGetShopGoodsPacket(WorldPacket * packet, const uint8 shopType, const uint8 labelType, const uint8 allPage, const uint8 curPage, std::list<GameGoods*> & lstGameGoods);
	/**
	 * @创建时间 2011-10-18
	 * @创建人 李志勇
	 * @函数作用 购买商品
	 * @参数
	 * 	@goodsId 商品ID
	 * 	@resultState 结果
	 *  @strBillId 实物订单号
	 */
	virtual bool CreateBuyGoodsPacket(WorldPacket * packet, const uint32 goodsId, const uint8 resultState, String strBillId = "");
	/**
	 * @创建时间 2011-11-08		
	 * @修改时间 2012-03-06 by StarX
	 * @创建人 李志勇
	 * @函数作用 获取大厅及房间人数
	 */
	virtual bool CreateGetHallAndRoomNumberPacket(WorldPacket * packet, const uint32 &town_id);
	/**
	 * @创建时间 2011-11-11
	 * @修改时间 2012-03-08 by StarX
	 * @创建人 李志勇
	 * @函数作用 获取效果
	 * @参数
	 * 	@pChr 角色对象
	 */
	virtual bool CreateGetEffectsPacket(WorldPacket * packet, CharPtr &pChr, const uint8 & type = 0, const uint32 & modelId = 0);
	/**
	 * @创建时间 2011-11-11
	 * @创建人 李志勇
	 * @函数作用 操作对象
	 * @参数
	 * 	@objectType 对象类型
	 * 	@objectId 对象ID
	 * 	@opType 操作类型
	 * 	@resultState 操作结果
	 */
	virtual bool CreateOperatorEffectsPacket(WorldPacket * packet, const uint8 objectType, const uint32 objectId, const uint8 opType, const uint8 resultState, ResourceProxy targetproxy = ResourceProxy());
	/**
	 * @创建时间 2011-11-14
	 * @创建人 李志勇
	 * @函数作用 下发系统设置
	 * @参数
	 * 	@pUser 用户对象
	 */
	virtual bool CreateSystemSetPacket(WorldPacket * packet, UserPtr &pUser);
	/**
	 * @创建时间 2017-10-20
	 * @创建人 roach
	 * @函数作用 下发公共系统设置
	 * @参数
	 * 	@pUser 用户对象
	 */
	virtual bool CreateCommonSetPacket(WorldPacket * packet, UserPtr &pUser);
	/**
	 * @创建时间 2011-11-25
	 * @创建人 李志勇
	 * @函数作用 通知客户端去大厅或者牌桌
	 * @参数
	 * 	@where 去向（1：大厅，2：牌桌）
	 */
	// virtual bool CreateGoHallOrTablePacket(WorldPacket * packet, const uint8 & where, TownPtr & pTown);

	/**
	 * @创建时间 2011-12-22
	 * @创建人 李志勇
	 * @函数作用 获取邮件列表
	 * @参数
	 *  @pChr 玩家
	 * 	@status 邮件状态（1：所有，2：已读，2：未读）
	 * 	@offset 请求偏移量
	 *  @num 数量
	 */
	virtual bool CreateGetMailsListPacket(WorldPacket * packet, CharPtr &pChr, const uint8 status, const uint16 offset, const uint8 num);
	/**
	 * @创建时间 2011-12-22
	 * @创建人 李志勇
	 * @函数作用 操作邮件结果包
	 * @参数
	 * 	@mailId 邮件ID
	 *  @operatorType 操作方式
	 *  @result	操作结果
	 */
	virtual bool CreateOperatorMailResultPacket(WorldPacket * packet, const uint32 mailId, const uint8 operatorType, const uint8 result);
	/**
	 * @创建时间 2011-12-22
	 * @创建人 李志勇
	 * @函数作用 下发邮件内容
	 * @参数
	 * 	@mailPtr 邮件
	 */
	virtual bool CreateSendMailContentPacket(WorldPacket * packet, GameMail &mailPtr);
	/**
	 * @创建时间 2011-12-22
	 * @创建人 李志勇
	 * @函数作用 下发未读邮件数量
	 * @参数
	 * 	@pUser 用户
	 */
	virtual bool CreateSendUnreadMailNumberPacket(WorldPacket * packet, UserPtr &pUser);

	/**
	 * @创建时间 2011-12-27
	 * @创建人 李志勇
	 * @函数作用 修改二级密码
	 * @参数
	 * 	@result 修改结果
	 */
	virtual bool CreateChangeSecondPwdPacket(WorldPacket * packet, const uint8 result);
	/**
	 * @创建时间 2011-12-27
	 * @创建人 李志勇
	 * @函数作用 验证二级密码结果
	 * @参数
	 * 	@result 验证结果
	 */
	virtual bool CreateValidateSecondPwdPacket(WorldPacket * packet, const uint8 result);
	/**
	 * @创建时间 2011-12-29
	 * @创建人 李志勇
	 * @函数作用 兑换兑换卡结果
	 * @参数
	 * 	@result 验证结果
	 */
	virtual bool CreateExchageTicketPacket(WorldPacket * packet, const uint8 result);

	// SMSG_EXCHANGEGATEWAYGOODS = 0x005B,	// 兑换网关配置道具
	virtual bool CreateExchangeGatewayGoodsPacket(WorldPacket * packet, const uint32 & prizes_id, const uint32 & num, 
													const uint32 & exchange_model_id, const uint32 & exchange_mode_num, const uint8 & result = 1);
	
	/**
	 * @创建时间 2012-01-20
	 * @创建人 李志勇
	 * @函数作用 更改昵称结果
	 * @参数
	 * 	@result 结果
	 */
	// virtual bool CreateRenamePacket(WorldPacket * packet, const uint8 result);
	/**
	 * @创建时间 2012-02-06
	 * @创建人 李志勇
	 * @函数作用 登录队列
	 * @参数
	 * 	@position 队列位置
	 */
	virtual bool CreateLoginQueuePacket(WorldPacket * packet, const uint32 position);
	
	/**
	 * @创建时间 2012-03-23
	 * @创建人 StarX
	 * @函数作用 0x0074 聊天交互
	 * @参数
	 *  @type 聊天类型1大厅 2房间 3私密
	 *  @srcChr 消息发送方
	 *  @szContent 消息内容
	 *  @color 颜色
	 */
	virtual bool CreateChatMessagePacket(WorldPacket * packet, const uint8 & type, CharPtr & srcChr, const String & szContent, CharPtr & target, const uint32 & color = 0);
	
	/**
	 * @创建时间 2016-05-23
	 * @创建人 Roach
	 * @函数作用 新喇叭聊天协议
	 * @参数
	 *  @srcChr 	消息发送方
	 *  @szContent 	消息内容
	 */
	virtual bool CreateSingleLabaChatPacket(WorldPacket * packet,CharPtr & srcChr, const String & szContent);

	
	/**
	 * @创建时间 2016-03-28
	 * @创建人 Roach
	 * @函数作用 0x0076 弹幕信息
	 * @参数
	 *  @danMu  弹幕信息
	 */
	virtual bool CreateDanMuInfoPacket(WorldPacket * packet,stDanMu danMu,const uint8 & result = 1);
	
	/**
	 * @创建时间 2016-03-28
	 * @创建人 Roach
	 * @函数作用 0x0077 弹幕历史信息
	 * @参数
	 *  @vDanMu  弹幕列表记录
	 */
	virtual bool CreateDanMuHistoryPacket(WorldPacket * packet,std::vector<stDanMu> vDanMu);
	
	/**
	 * @创建时间 2011-11-22
	 * @创建人 李志勇
	 * @函数作用 更新人物形象
	 * @参数
	 * 	@figuralId 人物形象
	 */
	virtual bool CreateUpdateFiguralPacket(WorldPacket * packet, const uint32 figuralId);
	
	/**
	 * @创建时间 2011-12-29
	 * @创建人 李志勇
	 * @函数作用 兑换兑换卡结果
	 * @参数
	 * 	@result 验证结果
	 */
	// bool CreateExchageTicketPacket(WorldPacket * packet, const uint8 result);
	
		/**
	 * @创建时间 2012-04-07
	 * @创建人 李志勇
	 * @函数作用 获取银行存款信息
	 * @参数
	 * 	@pChr 角色
	 */
	virtual bool CreateGetBankInfoPacket(WorldPacket * packet, GameBank &bank);
	/**
	 * @创建时间 2012-04-07
	 * @创建人 李志勇
	 * @函数作用 存款
	 * @参数
	 * 	@result 存款结果
	 * 	@type 类型
	 * 	@num 数量
	 */
	virtual bool CreatePutCoinsInBankPacket(WorldPacket * packet, const uint32 result, const uint32 type, const uint32 num);
	/**
	 * @创建时间 2012-04-07
	 * @创建人 李志勇
	 * @函数作用 取款
	 * @参数
	 * 	@result 取款结果
	 * 	@type 类型
	 * 	@num 数量
	 */
	virtual bool CreateGetCoinsFromBankPacket(WorldPacket * packet, const uint32 result, const uint32 type, const uint32 num);
	/**
	 * @创建时间 2012-05-07
	 * @创建人 李志勇
	 * @函数作用 获取玩家操作银行历史记录
	 * @参数
	 *  @pId platformId
	 * 	@num 每页数量
	 *  @page 页数
	 */
	virtual bool CreateGetBankHistoryPacket(WorldPacket * packet, const uint32 pId, const uint8 num, const uint16 page);
	/**
	 * @创建时间 2012-05-07
	 * @创建人 张楠
	 * @函数作用 获取玩家操作银行历史记录
	 * @参数
	 *  @pid
	 */
	virtual bool CreateUnreadMailNumPacket(WorldPacket * packet, const uint32 & pid);
	
	
	virtual bool 	CreateYellowStatusUpdate(WorldPacket *packet, const uint8 & type);
	/**
	 * @创建时间 2012-05-03
	 * @创建人 李志勇
	 * @函数作用 提醒玩家做某操作
	 * @参数
	 * 	@optType 操作类型（1：充值 2：升级提示 3：输赢超过每日上限 4：取消输赢上限锁）
	 */
	virtual bool CreateTellToDoPacket(WorldPacket * packet, 
									const uint32 optType, 
									const uint32 data1 = 0, 
									const uint32 data2 = 0, 
									const uint32 data3 = 0, 
									const uint32 data4 = 0);
	/**
	 * @创建时间 2012-04-05
	 * @创建人 李志勇
	 * @函数作用 获取成就列表
	 * @参数
	 * 	@pChr 角色对象
	 */
	virtual bool CreateGetEffortListPacket(WorldPacket * packet, CharPtr & pChr);
	/**
	 * @创建时间 2015-07-01
	 * @创建人 StarX
	 * @函数作用 获取成就列表
	 * @参数
	 * 	@pChr 角色对象
	 */
	virtual bool CreateGetEffortJsonListPacket(WorldPacket * packet, CharPtr & pChr);
	/**
	 * @创建时间 2013-05-06
	 * @创建人 roach
	 * @函数作用 成就列表信息
	 * @参数
	 * 	@pChr 角色对象
	 */
	virtual bool CreateServerEffortListPacket(WorldPacket * packet, CharPtr & pChr, std::list<EffectPtr> & effort_list);
	/**
	 * @创建时间 2012-04-07
	 * @创建人 李志勇
	 * @函数作用 获得新成就
	 * @参数
	 * 	@effortId 成就ID
	 */
	virtual bool CreateGetNewEffortPacket(WorldPacket * packet, const uint32 effortId);
	/**
	 * @创建时间 2012-11-01
	 * @创建人 StarX
	 * @函数作用 更新成就信息
	 * @参数
	 * 	@
	 */
	virtual bool CreateUpdateEffortPacket(WorldPacket * packet, const uint32 & effortId, const uint8 & status, 
								const uint32 & data1 = 0, const uint32 & data2 = 0);
	
	/**
	 * @创建时间 2013-05-06
	 * @创建人 Roach
	 * @函数作用 成就信息
	 * @参数
	 * 	@
	 */
	virtual bool CreateEffortInfoPacket(WorldPacket * packet,EffectPtr & effect);
	
	/**
	 * @创建时间 2013-05-06
	 * @创建人 Roach
	 * @函数作用 领取成就奖励
	 * @参数
	 * 	@
	 */
	virtual bool CreateGetEffortBountyPacket(WorldPacket * packet,const uint32 & eff_model_id,const uint8 & result = 1);
	/**
	 * @创建时间 2012-10-30
	 * @创建人 StarX
	 * @函数作用 新浪成就签名
	 * @参数
	 * 	@
	 */
	virtual bool CreateEffortSignPacket(WorldPacket * packet,const uint8 & type,const uint32 & serial,const uint32 & time_now,String code);
		
	/**
	 * @创建时间 2012-10-30
	 * @创建人 StarX
	 * @函数作用 用户主动领取操作
	 * @参数
	 * 	@
	 */
	// bool CreateEffortSignPacket(WorldPacket * packet,const uint8 & type,const uint32 & serial,const uint32 & time_now,String code);
	/**
	 * @创建时间 2012-10-30
	 * @创建人 StarX
	 * @函数作用 通知用户领取
	 * @参数
	 * 	@modelId 成就模式ID
	 */
	virtual bool CreateUserGainPacket(WorldPacket * packet, const uint8 & type, const uint32 & data1 = 0, 
								const uint32 & data2 = 0, const uint32 & data3 = 0);	
	
	/**
	 * @创建时间 2012-01-20
	 * @创建人 李志勇
	 * @函数作用 获得新成就
	 * @参数
	 * 	@modelId 成就模式ID
	 */
	virtual bool CreateNewTitlePacket(WorldPacket * packet, const uint32 modelId);
	/**
	 * @创建时间 2012-11-03
	 * @创建人 李志勇
	 * @函数作用 通知玩金皇冠
	 * @参数
	 *  @timeout 超时时间
	 *  @coins 初始铜钱
	 */
	virtual bool CreateNotifyPlayCoronalPacket(WorldPacket * packet, const uint8 timeout, const uint32 coins);
	/**
	 * @创建时间 2012-11-03
	 * @创建人 李志勇
	 * @函数作用 玩金皇冠
	 * @参数
	 * 	@turn 轮次
	 *  @result 结果
	 *  @winMoney 赢取的钱
	 */
	// virtual bool CreatePlayCoronalResultPacket(WorldPacket * packet, const uint8 result, const uint8 opt, GCPlayer *pgc);
		/**
	 * @创建时间 2012-11-05
	 * @创建人 StarX
	 * @函数作用 创建任务列表,任务模式表data1和data2表示奖励数值
	 * @参数
	 * 	@
	 */
	virtual bool CreateMissionListPacket(WorldPacket * packet, CharPtr & pChr);
	/**
	 * @创建时间 2012-11-05
	 * @创建人 StarX
	 * @函数作用 单个任务更新包
	 * @参数
	 * 	@
	 */
	virtual bool CreateMissionPacket(WorldPacket * packet, MissionPtr & pMission);
	
		/**
	 * @创建时间 2013-05-09
	 * @创建人 Roach
	 * @函数作用
	 * @参数
	 * 	@
	 */
	virtual bool CreateMaJonMissionListPacket(WorldPacket * packet, std::vector<MaJonMission> missions,const bool bAnime = true);
	/**
	 * @创建时间 2013-05-09
	 * @创建人 Roach
	 * @函数作用 单个任务更新包
	 * @参数
	 * 	@
	 */
	virtual bool CreateMajonMissionComplatePacket(WorldPacket * packet, MaJonMission pMission);
	
	/**
	 * @创建时间 2012-03-23
	 * @创建人 StarX
	 * @函数作用 0x0073 金皇冠和转盘
	 * @参数
	 *  @gameid 游戏ID, status 游戏状态, result 游戏结果
	 */
	virtual bool CreateSmallGameDataPacket(WorldPacket * packet, const uint8 & gameid, const uint8 & status, 
									const uint8 & result, const uint32 & data1 = 0, const uint32 & data2 = 0);
	/**
	 * @创建时间 2012-12-20
	 * @创建人 StarX
	 * @函数作用 0x0063 轮盘赌排行
	 * @参数
	 *  @vecString 排行列表
	 */
	virtual bool CreateRouletteTOPPacket(WorldPacket * packet, TownPtr & pTown);
	
	//CMSG_GETUSERCONTACT = 0x0064,		获取玩家联系信息
	virtual bool CreateGetUserContactPacket(WorldPacket * packet, CharPtr & pChr, String & strData);
	//CMSG_SETUSERCONTACT = 0x0065,		设置玩家联系信息
	virtual bool CreateSetUserContactPacket(WorldPacket * packet, CharPtr & pChr, String & strData, const uint8 & result = 1);
	
	/**
	 * @创建时间 2013-03-05
	 * @创建人 李志勇
	 * @函数作用 0x008A 财神卡生效
	 * @参数
	 *  @money 额外赠送的钱
	 */
	virtual bool CreateUsedMammonCardPacket(WorldPacket * packet, const uint32 money);
	/**
	 * @创建时间 2013-11-14
	 * @创建人 roach
	 * @函数作用 0x00B9 验证乐码
	 * @参数
	 *  @result 验证结果
	 */
	virtual bool CreateCheckLeCardResultPacket(WorldPacket * packet,const uint8 & result = 1);
	/**
	 * @创建时间 2013-11-14
	 * @创建人 roach
	 * @函数作用 0x00BA 领取乐码
	 * @参数
	 *  @result 结果（0 失败 1 成功）
	 */
	virtual bool CreateGetLeCardsResultPacket(WorldPacket * packet,const uint8 & result = 1);
	/**
	 * @创建时间 2013-11-18
	 * @创建人 roach
	 * @函数作用 0x00BB 乐码列表
	 * @参数
	 *  @exchanges 兑换列表
	 */
	virtual bool CreateLeCardsListPacket(WorldPacket * packet,std::list<GameExchange> * exchanges);
	/**
	 * @创建时间 2013-11-18
	 * @创建人 roach
	 * @函数作用 0x00BC 乐码领取冷却时间
	 * @参数
	 *  @timer 冷却时间倒计时
	 */
	virtual bool CreateLeCardsCoolDownPacket(WorldPacket * packet,const uint32 & timer);
	/**
	 * @创建时间 2013-11-18
	 * @创建人 roach
	 * @函数作用 0x00BC 乐码状态更新
	 * @参数
	 *  @timer 冷却时间倒计时
	 */
	virtual bool CreateLeCardsStatusPacket(WorldPacket * packet,const uint32 & le_id,const uint8 & status);
	/**
	 * @创建时间 2013-11-20
	 * @创建人 roach
	 * @函数作用 0x00BE 公共数据
	 * @参数
	 *  @data 注册时间
	 */
	virtual bool CreateUserPublicDataPacket(WorldPacket * packet,const uint32 & data);
	
	/**
	 * @创建时间 2013-03-20
	 * @创建人 roach
	 * @函数作用 0x00A0 VIP房间列表
	 * @参数
	 *  @offset 请求房间列表偏移位置
	 *  @num 	请求房间的数量
	 */
	virtual bool CreateVipRoomListPacket(WorldPacket * packet, const uint32 & update_time,const uint16 & offset,const uint16 & num,const uint16 & total_num,std::list<VipRoom> rooms);
	/**
	 * @创建时间 2013-03-20
	 * @创建人 roach
	 * @函数作用 0x00A0 VIP房间信息
	 * @参数
	 *  @vipRoom 房间结构体
	 */
	virtual bool CreateVipRoomInfoPacket(WorldPacket * packet, VipRoom vipRoom,const uint8 & nExist = 1);
	/**
	 * @创建时间 2013-03-20
	 * @创建人 roach
	 * @函数作用 0x00A0 创建VIP房间
	 * @参数
	 *  @room_id 	房间ID
	 *  @result 	结果
	 */
	virtual bool CreateCreateVipRoomPacket(WorldPacket * packet,const uint8 & result);
	/**
	 * @创建时间 2013-03-20
	 * @创建人 roach
	 * @函数作用 0x00A0 加入VIP房间
	 * @参数
	 *  @result 结果
	 */
	virtual bool CreateJoinVipRoomPacket(WorldPacket * packet,const uint8 & result);
	/**
	 * @创建时间 2013-03-20
	 * @创建人 roach
	 * @函数作用 0x00A0 离开VIP房间
	 * @参数
	 *  @result 结果
	 */
	virtual bool CreateLeaveVipRoomPacket(WorldPacket * packet,const uint8 & result = 1);
	/**
	 * @创建时间 2013-03-21
	 * @创建人 李志勇
	 * @函数作用 0x008A 幸运卡生效
	 * @参数
	 *  @luckyModelId 幸运卡模式ID
	 *  @usedPoint 消耗的幸运点数
	 *  @multiple 中奖倍数
	 *  @addCoins 额外赠送的钱
	 */
	bool CreateUsedLuckyCardPacket(WorldPacket * packet, const uint32 luckyModelId, const uint32 usedPoint, const float multiple, const uint32 addCoins);
	/**
	 * @创建时间 2013-06-14
	 * @创建人 StarX
	 * @函数作用 0x0020 手机版本住处
	 * @参数
	 *  @gzinfo 版本信息结构体
	 */
	bool CreateCheckVersionResultPacket(WorldPacket * packet, const GZIDInfo &gzinfo);
	/**
	 * @创建时间 2013-07-12
	 * @创建人 Roach
	 * @函数作用 0x00B6	玩家特效显示
	 * @参数
	 *  @gzinfo 版本信息结构体
	 */
	bool CreateCharSpecificPacket(WorldPacket * packet, const uint32 & char_id,const uint8 & type,const uint32 & data1 = 1,const uint32 & data2 = 0);
	/**
	 * @创建时间 2013-07-12
	 * @创建人 StarX
	 * @函数作用 0x00B8	牌桌中使用自身道具结果
	 * @参数
	 *  @
	 */
	bool CreateUsePropPacket(WorldPacket * packet, const uint32 & serial, const uint32 & propid, const uint8 & result);
	/**
	 * @创建时间 2013-11-22
	 * @创建人 StarX
	 * @函数作用 0x00BF	可使用形象列表
	 * @参数
	 *  @
	 */
	bool CreateBodyListPacket(WorldPacket * packet, CharPtr & pChr);
	/**
	 * @创建时间 2013-11-22
	 * @创建人 StarX
	 * @函数作用 特效操作广播(0x00C0)
	 * @参数
	 *  @
	 */
	bool 	CreateGraphicsPacket(WorldPacket* packet, const uint8 & type, const uint32 & data1, const uint32 & data2);
	/**
	 * @创建时间 2014-04-23
	 * @创建人 StarX
	 * @函数作用 转连服务器(0x00C2)
	 * @参数
	 *  @
	 */
	bool 	CreateLoginServerPacket(WorldPacket* packet, const GameServer & server, bool isAssert = true);
	/**
	 * @创建时间 2014-04-23
	 * @创建人 StarX
	 * @函数作用 转连服务器(0x00C3)
	 * @参数
	 *  @
	 */
	bool 	CreateChangeLinkServerPacket(WorldPacket* packet, const uint16 &active, const uint8 &result);
	/**
	 * @创建时间 2015-10-09
	 * @创建人 StarX
	 * @函数作用 兑换卡(0x0028)
	 * @参数
	 *  @
	 */
	bool 	CreateUserExchangePacket(WorldPacket* packet, uint8 result, std::map<uint16, uint32> &mapItems);
	/**
	 * @创建时间 2015-12-04
	 * @创建人 StarX
	 * @函数作用 发红包
	 * @参数
	 *  @
	 */
	bool 	CreateUpdateHongBaoPacket(WorldPacket* packet, uint32 hbId, uint8 status, uint32 src_pid, String src_nick, String create_time);
	/**
	 * @创建时间 2015-12-04
	 * @创建人 StarX
	 * @函数作用 抢红包
	 * @参数
	 *  @
	 */
	bool 	CreateGrabHongBaoPacket(WorldPacket* packet, uint32 hbId, uint32 src_pid, String src_nick, String head_url, uint32 getCoinsNum);
	/**
	 * @创建时间 2015-12-04
	 * @创建人 StarX
	 * @函数作用 红包历史记录
	 * @参数
	 *  @
	 */
	bool 	CreateHongBaoHistoryPacket(WorldPacket* packet, std::map<uint32, GamePubData> &mapHistory);
	/**
	 * @创建时间 2015-12-07
	 * @创建人 StarX
	 * @函数作用 抢红包详情
	 * @参数
	 *  @
	 */
	bool 	CreateHongBaoKnocklistPacket(WorldPacket* packet, const uint32 &hdId, std::list<HongBaoDetail> &lstDetail);
	/**
	 * @创建时间 2015-12-04
	 * @创建人 StarX
	 * @函数作用 请求红包发放
	 * @参数
	 *  @
	 */
	bool 	CreateHongBaoRequestPacket(WorldPacket* packet, uint8 surplus);
	/**
	 * @创建时间 2015-12-04
	 * @创建人 StarX
	 * @函数作用 发红包排行榜
	 * @参数
	 *  @
	 */
	bool 	CreateHongBaoTopListPacket(WorldPacket* packet, std::list<HongBaoTop> &lstHBTop);
	/**
	 * @创建时间 2015-12-10
	 * @创建人 StarX
	 * @函数作用 可抢红包记录
	 * @参数
	 *  @
	 */
	bool 	CreateHongBaoCanGrabListPacket(WorldPacket* packet, std::map<uint32, GamePubData> &mapHBList);
	
	/**
	 * @创建时间 2016-04-27
	 * @创建人 Roach
	 * @函数作用 JSON格式任务列表信息
	 * @参数 
	 *  @pChr  玩家角色数据
	 */
	bool 	CreateCommonJsonMissionListPacket(WorldPacket* packet, CharPtr & pChr);
	
	/**
	 * @创建时间 2016-04-27
	 * @创建人 Roach
	 * @函数作用 JSON格式单个任务信息
	 * @参数 
	 *  @model_id  	任务模式ID
	 *  @status 	任务状态
	 *  @curr_count 当前完成进度
	 *  @max_count  完成进度上限
	 */
	bool CreateCommonSingleJsonMissionPacket(WorldPacket * packet,
									const uint32 & model_id,
									const uint8 & status,
									const uint32 & curr_count,
									const uint32 & max_count);
	
	/**
	 * @创建时间 2016-04-27
	 * @创建人 Roach
	 * @函数作用 领取JSON格式任务奖励
	 * @参数 
	 *  @model_id  	任务模式ID
	 *  @result  	领取结果
	 */
	bool CreateGetJsonMissionBountyPacket(WorldPacket * packet,const uint32 & model_id,const uint8 & result = 1);
	
	/**
	 * @创建时间 2016-04-28
	 * @创建人 Roach
	 * @函数作用 JSON格式成就列表信息
	 * @参数 
	 *  @pChr  玩家角色数据
	 */
	bool 	CreateCommonJsonEffectListPacket(WorldPacket* packet, CharPtr & pChr);
	
	/**
	 * @创建时间 2016-04-28
	 * @创建人 Roach
	 * @函数作用 JSON格式单个成就信息
	 * @参数 
	 *  @model_id  	成就模式ID
	 *  @status 	成就状态
	 *  @curr_count 当前完成进度
	 *  @max_count  完成进度上限
	 */
	bool CreateCommonSingleJsonEffectPacket(WorldPacket * packet,
									const uint32 & model_id,
									const uint8 & status,
									const uint32 & curr_count,
									const uint32 & max_count);
	
	/**
	 * @创建时间 2016-04-28
	 * @创建人 Roach
	 * @函数作用 领取JSON格式成就奖励
	 * @参数 
	 *  @model_id  	成就模式ID
	 *  @result  	领取结果
	 */
	bool CreateGetJsonEffectBountyPacket(WorldPacket * packet,const uint32 & model_id,const uint8 & result = 1);
	
	/**
	 * @创建时间 2016-04-28
	 * @创建人 Roach
	 * @函数作用  公共排行数据
	 * @参数
	 *  @type	排行类型
	 *  @lstQT 	排行列表
	 */
	bool CreateCommonTopQueuePacket(WorldPacket * packet, const uint8 type, std::list<stCommonQueueTop> &lstQT);
	
	/**
	 * @创建时间 2016-04-28
	 * @创建人 Roach
	 * @函数作用  公共排行数据新
	 * @参数
	 *  @type	排行类型
	 *  @lstQT 	排行列表
	 */
	bool CreateCommonTopQueueNewPacket(WorldPacket * packet, const uint8 type, std::list<stCommonQueueTop> &lstQT, const uint8 & offset, const uint8 & num);
	
	/**
	 * @创建时间 2016-05-20
	 * @创建人 Roach
	 * @函数作用  通过PID获取玩家公共数据
	 * @参数
	 *  @bank 	银行数据
	 */
	bool CreatePubBankDataPacket(WorldPacket * packet, GameBank bank,const uint8 & result = 1);
	
	/**
	 * @创建时间 2016-07-27
	 * @创建人 Roach
	 * @函数作用	更新平台好友列表
	 * @参数
	 *  @lstFrdPid 	好友PID列表
	 */
	bool CreateUpdateCenterPlatformFriendPacket(WorldPacket * packet, const uint8 & result = 1);
	
	/**
	 * @创建时间 2016-07-19
	 * @创建人 Roach
	 * @函数作用  好友列表信息
	 * @参数
	 *  @lstFriend 	好友列表
	 */
	bool CreateCenterFriendListPacket(WorldPacket * packet, const uint8 & type, std::list<CenterGameFriend> lstFriend);
	
	/**
	 * @创建时间 2017-11-02
	 * @创建人 Roach
	 * @函数作用  系统推荐好友列表信息
	 * @参数
	 *  @lstFriend 	好友列表
	 */
	bool CreateCenterSystemFriendListPacket(WorldPacket * packet,std::list<ResourcePtr> lstFriend);
	
	/**
	 * @创建时间 2016-07-19
	 * @创建人 Roach
	 * @函数作用  好友信息
	 * @参数
	 *  @lstFriend 	好友列表
	 *  @mode 		模式（1 查看 2 添加）
	 */
	bool CreateCenterFriendInfoPacket(WorldPacket * packet, CenterGameFriend cFriend, const uint8 & mode);
	
	/**
	 * @创建时间 2016-07-19
	 * @创建人 Roach
	 * @函数作用  好友操作
	 * @参数
	 *  @destCharID		目标玩家ID
	 *  @mode			操作模式(1 添加 2 删除）
	 *  @result			结果（0 失败 1 成功）
	 */
	bool CreateCenterOperatorFriendPacket(WorldPacket * packet, const uint32 & destCharID, const uint8 & mode, const uint8 & result = 1);
	
	/**
	 * @创建时间 2016-07-20
	 * @创建人 Roach
	 * @函数作用  提交用户信息(0x0087)
	 * @参数
	 *  @type			类型（1 创建 2 更新）
	 *  @result			结果（0 失败 1 成功）
	 */
	bool CreateCommitCenterPlayerInfoPacket(WorldPacket * packet, const uint8 & type, const uint8 & result = 1);
	
	/**
	 * @创建时间 2016-07-20
	 * @创建人 Roach
	 * @函数作用  用户信息列表(0x0088)
	 * @参数
	 *  @pid		玩家PID
	 *  @gz_id		玩家所在分区ID
	 *  @lstData	中心玩家数据列表
	 */
	bool CreateCenterPlayerInfoListPacket(WorldPacket * packet, const uint32 & pid, const uint32 & gz_id, std::list<CenterFriendRecord> lstData);
	bool CreateCenterPlayerCountInfoPacket(WorldPacket * packet, const uint32 & pid, std::vector<stGzidSampleCountInfo> lstData);
	
	/**
	 * @创建时间 2016-08-08
	 * @创建人 Roach
	 * @函数作用  好友分组(0x008C)
	 * @参数
	 *  @lCate		分组列表
	 */
	bool CreateCenterFriendCategoryListPacket(WorldPacket * packet, std::list<CenterFriendCategory> lCate);
	
	/**
	 * @创建时间 2016-07-20
	 * @创建人 Roach
	 * @函数作用  分组操作(0x008D)
	 * @参数
	 *  @mode			类型（1 创建 2 删除）
	 *  @result			结果（0 失败 1 成功）
	 */
	bool CreateCenterFriendCategoryOperatorResultPacket(WorldPacket * packet, const uint8 & mode, const uint8 & result = 1);
	
	//============================公共组局相关================================
	/**
	 * @创建时间 2016-07-23
	 * @创建人 Roach
	 * @函数作用  申请创建组局结果(0x00F1)
	 * @参数
	 *  @packet		协议报
	 *  @result		结果
	 */
	bool CreateRequireCenterBattleResultPacket(WorldPacket * packet, const uint8 & result = 1);
	
	/**
	 * @创建时间 2016-07-26
	 * @创建人 Roach
	 * @函数作用  组局列表信息(0x00F2)
	 * @参数
	 *  @packet		协议报
	 *  @lcb		CenterBattle 列表
	 */
	bool CreateCenterBattleListPacket(WorldPacket * packet, std::list<CenterBattle> lcb);
	
	/**
	 * @创建时间 2016-07-25
	 * @创建人 Roach
	 * @函数作用  组局信息(0x00F3)
	 * @参数
	 *  @packet		协议报
	 *  @cb			CenterBattle 对象
	 */
	bool CreateCenterBattleInfoPacket(WorldPacket * packet, CenterBattle cb);
	
	/**
	 * @创建时间 2016-07-25
	 * @创建人 Roach
	 * @函数作用  (0x00F4)
	 * @参数
	 *  @packet		协议报
	 *  @result		结果
	 */
	bool CreateGameBattleResultPacket(WorldPacket * packet, const uint32 & cb_id, String join_code, const uint8 & result = 1);
	
	/**
	 * @创建时间 2016-07-25
	 * @创建人 Roach
	 * @函数作用  删除组局(0x00F5)
	 * @参数
	 *  @packet		协议报
	 *  @cb_id		组局ID
	 */
	bool CreateRemoveCenterBattlePacket(WorldPacket * packet, const uint32 & cb_id);
	
	/**
	 * @创建时间 2016-07-26
	 * @创建人 Roach
	 * @函数作用 	暂停，取消暂停牌桌(0x00F6) SMSG_CENTER_BATTLE_PAUSE
	 * @参数
	 *  @packet		协议报
	 *  @cb_id		组局ID
	 *  @result		结果
	 */
	bool CreateCenterBattleOpPacket(WorldPacket * packet, const uint8 & mode, const uint32 & cb_id, const uint32 & data, const uint8 & result = 1);
	
	/**
	 * @创建时间 2017-07-10
	 * @创建人 Roach
	 * @函数作用 	棋牌圈组局配置(0x00F7) SMSG_CENTER_BATTLE_CONFIG
	 * @参数
	 *  @packet		协议报
	 *  @cb_id		组局ID
	 *  @result		结果
	 */
	bool CreateCenterBattleConfigPacket(WorldPacket * packet, std::map<uint32, std::vector<stCenterBattleOpenCoins> > mapOpenCoins);
	
	/**
	 * @创建时间 2016-07-26
	 * @创建人 Roach
	 * @函数作用  组局牌桌踢人(0x00F7) SMSG_CENTER_BATTLE_KICK
	 * @参数
	 *  @packet		协议报
	 *  @cb_id		组局ID
	 *  @result		结果
	 */
	bool CreateCenterBattleKickPlayerPacket(WorldPacket * packet, const uint32 & cb_id, const uint32 & cid, const uint8 & result = 1);
	
	/**
	 * @创建时间 2016-07-26
	 * @创建人 Roach
	 * @函数作用  申请进入组局牌桌(0x00F8) SMSG_CENTER_BATTLE_JOINCHANNEL
	 * @参数
	 *  @packet		协议报
	 *  @join_code	验证码
	 *  @result		结果
	 */
	bool CreateCenterBattleJoinPacket(WorldPacket * packet, String join_code, const uint32 & gz_id, const uint8 & result = 1);
	
	/**
	 * @创建时间 2016-08-05
	 * @创建人 Roach
	 * @函数作用  玩家组局游戏记录(0x00F9) SMSG_CENTER_PLAYER_BATTLELOG
	 * @参数
	 *  @packet		协议报
	 *  @pChr		角色ptr
	 *  @logs		日志列表
	 */
	bool CreatePlayerCenterBattleLogsPacket(WorldPacket * packet, std::list<CenterBattleLog> logs);
	
	/**
	 * @创建时间 2016-08-05
	 * @创建人 Roach
	 * @函数作用  组局游戏记录(0x00FA) SMSG_CENTER_BATTLE_LOG
	 * @参数
	 *  @packet		协议报
	 *  @cb_id		组局ID
	 *  @logs		日志列表
	 */
	bool CreateCenterBattleLogPacket(WorldPacket * packet, std::list<CenterBattleLog> logs, const uint32 & cb_id, const uint16 & total_count, const uint16 & offset);
	
	// 创建即时牌局输赢包
	bool CreateCurrentCenterBattleWinLosePacket(WorldPacket * packet, CenterBattleLog log);
	bool CreateCurrentCenterBattleWinLosePacket(WorldPacket * packet, CenterBattle cb);
	
	// 创建组局单轮记录数据
	bool CreateCenterBattleSingleLoopLogPacket(WorldPacket * packet, const uint32 & cb_id, const uint8 & loop, CenterBattleLog log);
	
	//============================公共组局相关================================
	
	// 中秋活动 result: 0：领取失败 1：领取成功  2：未领取  3：已领取  
	bool CreateZhongQiuActivityPacket(WorldPacket * packet, const uint8 & result);
	
	// 通知通用在线奖励
	bool CreateNoticeCommonOnlineGiftPacket(WorldPacket * packet, String & strVal);
	// 领取通用在线奖励
	bool CreateGetCommonOnlineGiftResultePacket(WorldPacket * packet, const uint32 & id, const uint32 & coins, const uint8 & result = 0);
	
	// 转发字符串数据
	bool CreateHandleStringPacket(WorldPacket * packet, const uint8 & type, const uint32 & extra_data, String & strData);
	
	/**
	 * @创建时间 2012-03-02
	 * @创建人 李志勇
	 * @函数作用 下发附带一个基本类型附加数据的封包
	 * @参数
	 * 	@protocol 协议
	 * 	@baseData 附加数据
	 */
	template<typename T> bool CreateSimplePacket(WorldPacket * packet, const uint16 protocol, T baseData)
	{
		if(!packet)
			return false;
		packet->clear();
		if (typeid(T) == typeid(bool) || 
			typeid(T) == typeid(uint8) || 
			typeid(T) == typeid(int8) ||
			typeid(T) == typeid(uint16) || 
			typeid(T) == typeid(int16) ||
			typeid(T) == typeid(uint32) || 
			typeid(T) == typeid(int32) || 
			typeid(T) == typeid(float) )
		{
			// 预分配
			packet->reserve(32);
			packet->SetOpcode(protocol);
			*packet << protocol << uint16(0)
					<< baseData;
			// 设置包真正的长度
			packet->SetLength(packet->size());
			return true;
		}
		return false;
	}
	// 牌桌道具操作(0x0127)
	bool CreateOperatorPropPacket(WorldPacket * packet, 
							const uint8 & re, 
							const uint32 & src_id = 0, 
							const uint32 & propid = 0, 
							const uint32 & target = 0, 
							const uint32 & data1 = 0);
							
	
	/**
	 * @创建时间 2012-03-02
	 * @创建人 ly
	 * @函数作用 踢人提示协议的封包
	 * @参数
	 * 	
	 */	
	 bool CreateKickeOutNoticePacket(WorldPacket * packet, uint32 char_id, uint8 why);
	 
	 // 游戏录像
	 bool CreateGameRecordVedio(WorldPacket * packet, const uint32 & cb_id, const uint8 & loop_id, String record_data, const uint8 & mode = 1);
	 
	 // 赠送道具结果 0x0030
	 bool CreateGiveItemResultPacket(WorldPacket * packet, const uint32 & recv_pid, const uint32 & model_id, const uint32 & num, const uint8 & result = 1);
	 // 获取赠送获赠道具记录 0x0031
	 bool CreateGiveRecvItemLogsPacket(WorldPacket * packet, const uint32 & platform_id);
	 
	 //==========================评价系统相关================================
	 // 评价总体信息0x00E1
	 bool CreateJudgeTotalInfoPakcet(WorldPacket * packet, 
									const uint32 & pid, 
									const uint32 & total_judge_count,
									const uint32 & total_star,
									double star_level,
									const uint32 & start_game_count,
									const uint32 & play_game_count,
									float win_percent,
									const uint32 & total_win,
									float aver_winScore,
									String effect_label);
	
	// 评价玩家结果0x00E2
	bool CreateJudgePlayerResultPacket(WorldPacket * packet, 
										const uint32 & target_id,
										const uint32 & target_type,
										const uint32 & pid,
										const uint32 & judge_pid,
										const uint8 & level, 
										std::vector<uint8> vLabel, 
										String judge_info,
										const uint8 & result = 1);
	
	// 评价信息列表0x00E3
	bool CreateJudgeInfoListPacket(WorldPacket * packet, 
									const uint32 & pid, 
									const uint32 & offset,
									const uint8 & num,
									std::list<CenterJudge> cj_list);
	 
	 // 评价信息确认0x00E4
	 bool CreateJudgeResultListPacket(WorldPacket * packet, const uint32 & target_id, const uint32 & target_type, std::vector<uint32> vPid);
	//==========================评价系统相关================================
	
	//==========================棋牌圈牌桌相关=============================
	// 同IP玩家列表信息 0x00EA
	bool CreateCenterBattleSameIpPlayersPacket(WorldPacket * packet, std::map<uint32, std::vector<CharPtr> > mapSameIPChars, const uint8 & wait_timer);
	// 创建同意或拒绝游戏协议包 0x00EB
	bool CreateAgreeOrRefusePacket(WorldPacket * packet, const uint8 & agree, const uint32 & char_id, const uint8 & result = 1);
	// 组局牌桌相关信息 0x2001
	bool CreateCenterBattleInfoPacket(WorldPacket * packet, String strCBInfo);
	// 玩家选择座位0x2002
	bool CreatePlayerChooseSeatPacket(WorldPacket * packet, const uint8 & pos, const uint8 & result);
	// 玩家发起投票0x2003
	bool CreateSendVotePacket(WorldPacket * packet, const uint32 & char_id, const uint8 & result);
	// 投票列表0x2004
	bool CreateVoteListPacket(WorldPacket * packet, std::map<uint32, stVotePlayer> mapVote, const uint16 & think_time, const uint8 & status = 0);
	// 牌桌解散 0x2005
	bool CreateDissolveChannelPacket(WorldPacket * packet, const uint8 & reson);
	// 牌局开始前读秒 0x2006
	bool CreateWaitGameStartTimePcket(WorldPacket * packet, const uint32 & timer, const uint32 & type = 0);
	
	//===========================周边的一些公共协议===============================
	// 创建赠送免费互动道具 0x2010
	bool CreateGiveFreeGiftPacket(WorldPacket * packet, const uint32 & send_charID, const uint8 & gift_id, std::vector<uint32> vCharIDs, const uint8 & result = 1);
	// 创建玩家请求是否可以进入组局 0x2011
	bool CreateRequireCanJoinCenterBattlePacket(WorldPacket * packet, String & join_code, const uint8 & result);
	// 创建组局公共房列表 0x2012
	bool CreateCenterBattlePublicListPacket(WorldPacket * packet, const uint32 & game_id, std::list<CenterBattle> vCb);
	// 创建或加入随机组局房 0x2013
	bool CreateCreateOrJoinRandomCenterBattle(WorldPacket * packet, String strJoinCode, const uint16 & gz_id, const uint8 & result = 1);
	// 获取斗地主公共房列表 0x2014（目前针对斗地主）
	bool CreateDDZPublicCenterBattleListPacket(WorldPacket * packet, const uint16 & room_id, const uint16 & hall_id, const uint16 & total_count, const uint16 & offset, const uint16 & num, std::list<CenterBattle> lstBattles);
	// 组局牌桌上锁结果 0x2015
	bool CreateSetBattleLockResutlPacket(WorldPacket * packet, const uint32 & cb_id, String passwd, const uint8 & result = 1);
	// SMSG_CENTER_CHANGECENTERBATTLE = 0x2016,		组局换桌
	bool CreateChangeCenterBattlePacket(WorldPacket * packet, const uint32 & cb_id, const uint8 & result);
	
	// 创建组局房间玩家信息 0x2020
	bool CreateCenterBattlePlayerInfoPacket(WorldPacket * packet, CenterBattle cb);
	// 创建玩家最近组局单场记录信息 0x2021
	bool CreateCenterBattlePlayerSingleLogPacket(WorldPacket * packet, 
												const uint32 & offset,
												const uint32 & total_count, 
												std::list<CenterBattleLog> logs);
	// 创建某分区某房间玩家数量 0x2022
	bool CreateTownPlayerCountByGzid(WorldPacket * packet, const uint32 & gz_id, const uint32 & town_id, const uint32 & num);
	// SMSG_CENTERBATTLE_MATCHZONELOGS = 0x2023,		// 赛区战绩记录列表
	bool CreateCenterBattleMatchZoneLogsPacket(WorldPacket * packet, 
												const uint32 & zone_id, 
												const uint32 & offset, 
												const uint32 & total_count, 
												std::list<CenterBattleLog> logs);
	
	
	// 创建分享活动信息 0x2030
	bool CreateCommonActivityInfoPacket(WorldPacket * packet, const uint32 & agent_id, EffectPtr & effectPtr);
	// 创建公共用户信息 0x2032
	bool CreateCommonUserConfigInfoPacket(WorldPacket * packet, const uint32 & platform_id, const uint32 & gz_id, String strConfig);
	
	// 创建公共签到信息包 0x2033
	bool CreateCommonSignInfoPacket(WorldPacket * packet, stCommonSign cs);
	// 创建签到结果信息包 0x2034
	bool CreateCommonSignResultPacket(WorldPacket * packet, const uint8 & sign_type, const uint8 & data, const uint8 & result = 1);
	
	// 创建个性签名信息包 0x2035
	bool CreateCommonSignNamePacket(WorldPacket * packet, const uint32 & platform_id, String & content);
	
	//SMSG_DDZ_CHANNELLISTINFO = 0x2037,	// 斗地主牌桌列表信息
	bool CreateDDZChannelListInfoPacket(WorldPacket * packet, const Json::Value & val);
	
	//==========================麻将相关协议======================================

	//SMSS_MJ_GameStatus = 0x2500,	//游戏状态
	bool 	CreateMJGameStatusPacket(WorldPacket * packet, const CMD_GameStart & gamestart);

	//SMSS_MJ_MagicCard = 0x2501,	//癞子牌列表
	bool 	CreateMJMagicCardsListPacket(WorldPacket * packet, std::vector<uint8 >  vecMagicCards,const uint8 & ui8PlayerPosID = 0);

	//SMSS_MJ_HandCard = 0x2502,	//玩家手牌
	bool 	CreateMJHandCardPacket(WorldPacket * packet, std::vector<uint8>  vecHandCardsList,const uint8 & type = enSendCardType_All);

	//SMSS_MJ_BuHuaCard = 0x2503,	//补花
	bool 	CreateMJBuHuaListPacket(WorldPacket * packet,const uint8 & ui8PlayerChairID,const uint8 & ui8HuaPai);

	//SMSS_MJ_GiveCard = 0x2504,	//摸牌
	bool 	CreateMJSendCardPacket(WorldPacket * packet, CMD_SendCard & SendCard, bool bAction = true);

	//SMSS_MJ_OutCardNotify = 0x2505,	//通知出牌
	bool 	CreateMJCastCardNotify(WorldPacket * packet, const uint8 & ui8PlayerChairID, const uint32 & ui32LeftTime);

	//SMSS_MJ_OutCard = 0x2506,		//出牌 对玩家自己
	bool 	CreateMJOutCardPacket(WorldPacket * packet, const uint8 & ui8OutCardData, const uint8 & ui8OutResult);

	//SMSS_MJ_OutCardForAllPlayer = 0x2507,	//玩家出牌 对所有玩家
	bool 	CreateMJOutCardForAllPlayerPacket(WorldPacket * packet, const uint8 & ui8PlayerChairId, const uint8 & ui8CardData);

	//SMSS_MJ_OperateNotify = 0x2508,		//动作提示
	bool 	CreateMJOperateNotifyPacket(WorldPacket * packet, CMD_OperateNotify & OperateNotify);

	//SMSS_MJ_Operate = 0x2509,		//玩家进行操作
	bool 	CreateMJOperatePacket(WorldPacket * packet, const uint8 & ui8Action, const uint8 & ui8OperateCard, const uint8 & ui8Result);

	//SMSS_MJ_OperateChiPengGang = 0x250A,		//玩家吃碰杠
	bool 	CreateMJOperatePengGangPacket(WorldPacket * packet, const  uint8 & ui8PlayerChairID, tagWeaveItem & WeaveItem,const uint8 & m_ui8ProvideCard);

	//SMSS_MJ_OperateListen = 0x250B,		//玩家听牌
	bool 	CreateMJOperateListenPacket(WorldPacket * packet, const  uint8 & ui8PlayerChairID);

	//SMSS_MJ_OperateHu = 0x250C,		//玩家胡
	bool 	CreateMJOperateHuPacket(WorldPacket * packet,
		const  uint8 & ui8PlayerChairID,
		std::vector<uint8 > vecCardslist,
		std::vector<tagWeaveItem> & vecWeaveItem,
		const uint8 & ui8CenterCard,
		const uint8 & ui8HuFanXing,
		const uint8 & ui8ProvidePos,
		const uint8 & ui8HuType,
		const uint32 & ui32ExData = 0);

	//SMSS_MJ_Animation = 0x250D,		//牌桌动画
	bool 	CreateMJAnimationPacket(WorldPacket * packet, const uint8 & ui8PlayerChairID, const uint8 & ui8AnimationType);

	//SMSS_MJ_LiangPai = 0x250E,	//亮牌
	bool 	CreateMJLiangPaiPacket(WorldPacket * packet,std::vector<std::vector<uint8> > & vecCardsList,std::vector<std::vector<tagWeaveItem> > & vecWeave,bool bLiuJu);

	//SMSS_MJ_PlayerStatus = 0x250F,//玩家状态
	bool 	CreateMJPlayerStatusPacket(WorldPacket * packet, const uint8 & ui8PlayerChairID, const uint8 & ui8Status);

	//SMSS_MJ_Reconnection = 0x2510,//玩家重新连接连接
	bool    CreateMJReconnectionPacket(WorldPacket * packet,
		std::vector<uint8> vecHandCardsList,
		std::vector<uint8> vecPlayerCardCount,
		std::vector<std::vector<tagWeaveItem> > vecWeaveItem,
		std::vector<std::vector<uint8> > vecPlayerDiscardCard,
		uint8 ui8LastCard);

		//========定缺============
	//SMSS_MJ_XuanQueNotify = 0x2511,//选缺通知
	bool   CreateMJXuanQueNotifyPacket(WorldPacket * packet, uint8 vecDefaultCards,const uint32 & ui32LeftTime);

	//SMSS_MJ_PlayerXuanQue = 0x2512,//玩家选缺结果
	bool   CreateMJPlayerXuanQueResultPacket(WorldPacket * packet, uint8 vecDefaultCards, const uint8 & ui8Result);

	//SMSS_MJ_XuanQueList = 0x2513,//广播选缺结果
	bool   CreateMJXuanQueListPacket(WorldPacket * packet, std::vector<uint8> vecXuanQueList,bool bAction = true);

		//========换牌============
	//SMSS_MJ_SwapCardNotify = 0x2514,//通知换牌
	bool  CreateMJSwapCardsNotifyPacket(WorldPacket * packet, std::vector<uint8> vecDefaultCards,const uint32 & ui32LeftTime);

	//SMSS_MJ_PlayerSwapCard = 0x2515,		//玩家换牌
	bool  CreateMJPlayerSwapCardsResultPacket(WorldPacket * packet, std::vector<uint8> vecDefaultCards, const uint8 & ui8Result);

	//SMSS_MJ_SwapCardList = 0x2516,		//换牌结果
	bool  CreateMJSwapCardsResultPacket(WorldPacket * packet, std::vector<uint8> vecGetCards,const uint8 & uiFrom);

	//===============================

	//SMSS_MJ_PlayerInfo = 0x2517,		//麻将框架玩家列表
	virtual bool CreateMJPlayerInfoPacket(WorldPacket * packet, MJBaseTablePlayer *  pMJTablePlayer);

	//SMSS_MJ_WatchList = 0x2518,			//观战列表
	virtual bool CreateMJWatchListPacket(WorldPacket * packet, std::map<uint32, MJBaseTablePlayer > & mapWatchList);

	//SMSS_MJ_MaPaiInfo = 0x251A,			//马牌
	bool   CreateMJMaPaiInfoPacket(WorldPacket * packet, std::vector< std::vector<uint8> > vecMaPaiList, std::vector< std::vector<uint8> > vecZhongMaList);

	//SMSS_MJ_TingPaiList = 0x251B,			//听牌列表
	bool   CreateMJTingPaiListPacket(WorldPacket * packet, std::vector<uint8> vecTingList);

	//SMSS_MJ_ScoreChange = 0x251D,				//分数变更
	bool   CreateMJScoreChangePacket(WorldPacket * packet, std::vector<MJScoreChange> vecScoreChangeList);

	//SMSS_MJ_ConstantlyCale = 0x251E,			//及时输赢
	bool   CreateMJConstantlyCalePacket(WorldPacket * packet, std::vector<MJConstantlyCale > vecTablePlayerList);

	//SMSS_MJ_ChooseSwapPosNotify = 0x251F,			//通知玩家选换牌位置
	bool  CreateMJChooseSwapPosNotifyPacket(WorldPacket *packet,const uint8 & ui8Pos, const uint32 & ui32LeftTime);

	//SMSS_MJ_BankerChooseSwapPos = 0x2520,			//玩家选择换牌位置
	bool  CreateMJPlayerChooseSwapPosPacket(WorldPacket *packet, const uint8 & ui8Pos,const uint8 & ui8Type,const uint8 & ui8Result);

	//SMSS_MJ_HuaPaiList = 0x2521,					//玩家花牌列表
	bool  CreateMJPlayerHuaPaiListPacket(WorldPacket *packet, const uint8 & ui8Pos,std::vector<uint8> vecHuaPaiList);

	//===========================================================================	

//=========================俱乐部相关begin=======================================
	//SMSG_CLUB_NORMALINFO = 0x2100,  俱乐部资料
	bool	CreateClubNormalInfoPacket(WorldPacket * packet, CenterClub & cc);
	//SMSG_CLUB_INFO = 0x2101,	查看俱乐部大厅信息
	bool	CreateClubHallInfoPacket(WorldPacket * packet, CenterClub & cc, std::list<CenterClubMember> lstClubMember, std::list<CenterClubMessage> lstClubMessage, const uint32 & src_pid);
	//SMSG_CLUB_LIST = 0x2102,	俱乐部列表信息
	bool 	CreateClubListInfoPacket(WorldPacket * packet, const uint8 & type, std::list<CenterClub> lCC);
	
	//SMSG_CLUB_CREATE = 0x2103,	创建俱乐部
	bool 	CreateClubCreateResultPacket(WorldPacket * packet, const uint32 & club_id, const uint8 & result = 0);
	//SMSG_CLUB_REQUIREJOIN = 0x2104,	请求加入俱乐部
	bool 	CreateRequireJoinClubResultPacket(WorldPacket * packet, const uint32 & club_id, const uint8 & result = 0);
	//SMSG_CLUB_REVIEW = 0x2105,	审核操作（申请加入/带入金额）
	bool 	CreateClubReviewResultPacket(WorldPacket * packet, const uint32 & club_id, const uint8 & type, const uint8 & result = 0);
	//SMSG_CLUB_REVIEW = 0x2106,	审核历史（加入/带入）
	bool 	CreateClubReviewLogsPacket(WorldPacket * packet, const uint32 & club_id, const uint8 & type, std::list<CenterClubLog> lstLogs);
	//SMSG_CLUB_TAKEIN = 0x2107,	带入金币结果
	bool	CreateClubTakeinResultPacket(WorldPacket * packet, const uint32 & club_id, const uint32 & coins, const uint8 & result = 0);
	//SMSG_CLUB_RETURNCOINS = 0x2108,	退分
	bool 	CreateClubReturnCoinsPacket(WorldPacket * packet, const uint32 & club_id, const uint32 & coins, const uint8 & result = 0);
	//SMSG_CLUB_BUYPLAYERRANK = 0x2109,	 	购买会员
	bool 	CreateClubBuyPlayerRankResult(WorldPacket * packet, const uint8 & rank, const uint8 result = 0);
	//SMSG_CLUB_BUYCLUBRANK = 0x210A,		购买俱乐部星级
	bool 	CreateClubBuyClubRankResult(WorldPacket * packet, const uint32 & club_id, const uint8 & rank, const uint8 result = 0);
	//SMSG_CLUB_EXITCLUB = 0x210B,			退出公会
	bool 	CreateClubPlayerExitResult(WorldPacket * packet, const uint32 & club_id, const uint8 & result = 0);
	//SMSG_CLUB_CHANGEQUANXIAN = 0x210C,	权限调整
	bool 	CreateClubChangeQuanXianResult(WorldPacket * packet, const uint32 & club_id, const uint32 & pid, const uint8 & member_type, const uint8 & result = 0);
	//SMSG_CLUB_KICKOUT = 0x210D,			踢出玩家
	bool 	CreateClubKickOutResult(WorldPacket * packet, const uint32 & club_id, const uint32 & pid, const uint8 & result = 0);
	//SMSG_CLUB_CHATLIST = 0x210E,			聊天列表信息
	bool 	CreateClubChatlistPacket(WorldPacket * packet, const uint32 & club_id, std::list<CenterClubMessage> lstMessage);
	//SMSG_CLUB_CHAT = 0x210F,				聊天信息
	bool 	CreateClubChatInfoPacket(WorldPacket * packet, const uint32 & club_id, CenterClubMessage message);
	//SMSG_CLUB_TAKEINMEESAGELIST = 0x2110,		俱乐部带入消息列表
	bool 	CreateClubTakeinMessageListPacket(WorldPacket * packet, const uint32 & club_id, std::list<CenterClubMessage> lstMessage);
	//SMSG_CLUB_CHENGJIPAIHANG = 0x2113,	俱乐部成绩排行
	bool 	CreateClubChengjiOrderPacket(WorldPacket * packet, const uint32 & club_id, std::list<CenterClubMember> lstMember);
	//SMSG_CLUB_ROOMLIST = 0x2114,			俱乐部房间列表
	bool 	CreateClubRoomListPacket(WorldPacket * packet, const uint32 & club_id, const uint32 & type, std::list<CenterClubRoom> lstRoom);
	//SMSG_CLUB_CREATEROOM = 0x2115			俱乐部创建房间结果
	bool 	CreateClubCreateRoomResultPacket(WorldPacket * packet, const uint32 & club_id, const uint32 & room_id, String strData, const uint8 & result = 0);
	//SMSG_CLUB_GOODSLIST = 0x2116,			俱乐部商城道具列表
	// bool 	CreateClubGoodsPacket(WorldPacket * packet, std::list<CenterClubConfig> lstGoods);
	//SMSG_CLUB_BUYGOODS = 0x2117,			俱乐部购买商品
	bool 	CreateCLubBuyGoodsResultPacket(WorldPacket * packet, const uint32 & goods_id, const uint8 & result = 0);
	//SMSG_CLUB_PLAYERINFO = 0x2118,		俱乐部玩家信息
	bool 	CreateClubPlayerInfoPacket(WorldPacket * packet, CharPtr & pChr);
	//CMSG_CLUB_CURRSCORE = 0x02119,		俱乐部玩家当前积分
	bool 	CreateClubPlayerCurrScorePacket(WorldPacket * packet, const uint32 & club_id, const uint32 & curr_score);
	//SMSG_CLUB_DISSOLVE = 0x211A,			解散俱乐部
	bool 	CreateClubDissolvePacket(WorldPacket * packet, const uint32 & club_id, const uint8 & result = 0);
	//SMSG_CLUB_CHANGECLUBINFO = 0x211B,	修改俱乐部信息
	bool 	CreateClubChangeInfoResultPacket(WorldPacket * packet, const uint32 & club_id, const uint32 & type, String & strData, const uint8 & result = 0);
	
	//SMSG_CLUB_REMARKINFO = 0x211C,		玩家备注信息
	bool 	CreatePlayerClubRemarkInfoPacket(WorldPacket * packet, CenterClubLabel & ccLabel, std::list<CenterClubRemark> lstClubRemark);
	//SMSG_CLUB_ADDREMARK = 0x211D,			设置玩家备注信息
	bool 	CreateSetPlayerClubRemarkResultPacket(WorldPacket * packet, const uint32 & dest_id, const uint8 & result = 0);
	//SMSG_CLUB_CHANGEGROUPNAME = 0x211E,	修改备注分组名称
	bool 	CreateChangeClubGroupLabelPacket(WorldPacket * packet, const uint8 & index, String & strName, const uint8 & result = 0);
	//SMSG_CLUB_ADDREMARKLABEL = 0x211F,	添加标签名称
	bool 	CreateAddLabelNameResultPacket(WorldPacket * packet, String & strLabelName, const uint8 & result = 0);
	//SMSG_CLUB_REMOVEREMARKLABEL = 0x2120,	移除标签名称
	bool 	CreateRemoveLabelNameResultPacket(WorldPacket * packet, String & strLabelName, const uint8 & result = 0);
	//SMSG_CLUB_REMOVEREMARKPLAYER = 0x2121,移除备注玩家信息
	bool 	CreateRemoveRemarkPlayerPacket(WorldPacket * packet, const uint32 & dest_pid, const uint8 & result = 0);
	//SMSG_CLUB_PLAYERDETAILS = 0x2122,		俱乐部玩家详细信息
	bool 	CreateClubPlayerDetailsPacket(WorldPacket * packet, CharPtr & pChr, String & remark_info);
	//SMSG_CLUB_CHOOSESEATBATTLELIST = 0x2123, 	俱乐部选座房牌局列表
	bool 	CreateClubChooseSeatBattleListPacket(WorldPacket * packet, const uint32 & club_id, const uint32 & room_id, const uint16 & total_count, 
													const uint16 & offset, const uint16 & num, std::list<CenterBattle> lstBattles);
	//SMSG_CLUB_BATTLEHISTORYLOG = 0x2124,	俱乐部历史战绩
	bool 	CreateClubBattleHistoryPacket(WorldPacket * packet, const uint32 & club_id, const uint32 & offset, const uint32 & total_num, std::list<CenterBattleLog> logs);
	//SMSG_CLUB_REVIEWCOUNT = 0x2125,		俱乐部审核消息数量（用于显示审核旁边的红点）
	bool 	CreateClubMessageListCountPacket(WorldPacket * packet, const uint32 & club_id, const uint8 & type, const uint16 & count, String & strCLubName, bool bRequire = false);
	//SMSG_CLUB_JOINMEESAGELIST = 0x2126,	俱乐部加入消息列表
	bool 	CreateClubJoinMessageListPacket(WorldPacket * packet, const uint32 & club_id, std::list<CenterClubMessage> lstMessage);
	//SMSG_CLUB_EXITCOINSLOGS = 0x2127,		俱乐部退分历史
	bool 	CreateClubExitCoinsLogsPacket(WorldPacket * packet, const uint32 & club_id, std::list<CenterClubLog> lstLogs);
	
	//SMSG_CLUB_MTFCLUBINFO = 0x2129,		满天星俱乐部信息
	bool 	CreateMTFClubInfoPacket(WorldPacket * packet, CenterClub & club, std::list<CenterClubMember> lstManger, std::list<CenterClubMember> lstMember);
	//SMSG_CLUB_HISTORYCHENGJI = 0x212A,	俱乐部历史成绩
	bool	CreateClubHistoryChengJiPacket(WorldPacket * packet, stClubHistoryBattle stCHB);
	//SMSG_CLUB_CREATEMTF = 0x212B,			创建满天飞俱乐部
	bool 	CreateClubCreateMTFResultPacket(WorldPacket * packet, const uint32 & club_id, const uint8 & result = 0);
	//SMSG_CLUB_LISTMTF = 0x212C,			俱乐部列表信息-满天飞
	bool 	CreateClubListInfoMTFPacket(WorldPacket * packet, const uint8 & type, std::list<CenterClub> lCC);
	
	//SMSG_CLUB_CREATEFASTMODE = 0x212D,	创建快速开房配置
	bool 	CreateClubFastModeCreatePacket(WorldPacket * packet, const uint32 & club_id, const uint8 & result = 0);
	//SMSG_CLUB_DELETEFASTMODE = 0x212E,	删除快速开房配置
	bool 	CreateClubFastModeDeletePacket(WorldPacket * packet, const uint32 & club_id, const uint8 & index, const uint8 & result = 0);
	//SMSG_CLUB_GETFASTMODE = 0x212F,		获取快速开房配置
	bool 	CreateClubFastModeListPacket(WorldPacket * packet, const uint32 & club_id, Json::Value & val);
	
//==========================俱乐部相关end========================================

	// SMSG_COMMON_CONFIGMISSIONLIST = 0x2200, 				// 配置任务列表
	bool 	CreateCommonConfigMissionListPacket(WorldPacket * packet, String & strParams, const uint8 & type = 0);
	// SMSG_COMMON_CONFIGMISSIONGET = 0x2201,				// 领取配置任务
	bool 	CreateCommonConfigMissionGetPacket(WorldPacket * packet, const uint32 & type, const uint32 & index, const uint8 & result = 1);
	// SMSG_COMMON_UPDATECONFIGMISSIONSTATUS = 0x2202,		// 任务状态更新
	bool	CreateCommonConfigMissionStatusUpdatePacket(WorldPacket * packet, const uint32 & type, const uint32 & index, const uint8 & status);
	
	//=======================比赛相关begin-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

#ifdef CENTERMATCH

	//SMSS_CenterMatch_PublicMatchList = 0x2700,				//比赛列表
	bool CreateCenterMatchPublicMatchListPacket(WorldPacket * packet, std::list<CenterMatch>& CenterMatchList, const uint8 & type);

	////SMSS_CenterMatch_PlayerMatchList = 0x2701,				//比赛列表
	//bool CreateCenterMatchPlayerMatchListPacket(WorldPacket * packet, std::list<CenterMatch> & CenterMatchList);

	//SMSS_CenterMatch_MatchInfo = 0x2702,				//比赛信息
	bool CreateCenterMatchInfoPacket(WorldPacket * packet,const uint32 & cm_id, std::map<uint32, CenterMatchChannelInfo > MatchChannel);

	//SMSS_CenterMatch_EnrollmentForm = 0x2703,			//报名列表
	bool CreateCenterMatchEnrollmentFormPacket(WorldPacket* packet, const uint32 & cm_id,std::list<CenterMatchPlayer > cmpList);

	//SMSS_CenterMatch_SignUp = 0x2704,					//报名结果
	bool CreateCenterMatchPlayerSignUpPacket(WorldPacket* packet,const uint32 & cm_id,String join_code,const  uint32 & chr_id, uint8 result);


	//SMSS_CenterMatch_ReviewSignUp = 0x2705,					//审核报名结果
	bool CreateCenterMatchReviewSignUpPacket(WorldPacket* packet, const uint32 & cm_id, const  uint32 & chr_id, uint8 result);

	//SMSS_CenterMatch_PlayerInfoListInCenter = 0x2706,					//玩家信息
	bool CreateCenterMatchPlayerInfoListInCenterPacket(WorldPacket * packet,CharPtr pChr, CenterMatch cm, std::map<uint32, CenterMatchPlayerInfo > MatchPlayer);

	//SMSS_CenterMatch_CreateMatch = 0x2707,						//创建比赛
	bool CreateCenterMatchCreateMatchPacket(WorldPacket * packet, const uint32 & cm_id, String str, uint8 result);

	//SMSS_CenterMatch_EnterMatch = 0x2708,						//加入比赛
	bool CreateCenterMatchEnterMatchPacket(WorldPacket * packet, const uint32 & cm_id, const uint32 & gz_id, uint8 result);

	//SMSS_CenterMatch_PlayerEnterMatchList = 0x2709,						//已经入比赛列表
	bool CreateCenterMatchPlayerEnterMatchListPacket(WorldPacket * packet, std::list<CenterMatchPlayer> & playerList);
	
	//SMSS_CenterMatch_PlayerGiveUpMatch = 0x270A,						//玩家退赛
	bool CreateCenterMatchPlayerGiveUpMatchPacket(WorldPacket * packet, const uint32 & cm_id, const uint8 & result);

	//SMSS_CenterMatch_CenterMatchDissolve = 0x270B,						//解散比赛
	bool CreateCenterMatchDissolve(WorldPacket * packet, const uint32 & cm_id, const uint8 & result);
	
	//SMSS_CenterMatch_CenterMatchWatch = 0x270C,							//比赛观战
	bool CreateCenterMatchWatchPacket(WorldPacket * packet, const uint32 & cm_id, const uint32 & channel_id, const uint32 & gz_id, const uint8 & result = 1);
	
	//SMSS_CenterMatch_CenterMatchLog = 0x270D,							//比赛游戏记录
	bool CreateCenterMatchLogPacket(WorldPacket * packet, std::list<CenterMatch> logs, const uint32 & cm_id, const uint16 & total_count, const uint16 & offset);

	//SMSS_CenterMatch_CenterMatchLoopLog = 0x270E,							//比赛游戏记录
	bool CreateCenterMatchLoopLogPacket(WorldPacket * packet, std::list<CenterBattleLog> logs, const uint32 & cm_id,const uint32 & channelId, const uint16 & total_count, const uint16 & offset);

	//SMSS_CenterMatch_CenterMatchBattlelog = 0x270F,							//单局比赛游戏记录
	bool CreateCenterMatchBattleLogPacket(WorldPacket * packet, std::list<CenterBattleLog> logs);

	//SMSS_CenterMatch_WaitJoinChannel = 0x2720,					//等待进入牌桌
	bool CreateCenterMatchWaitJoinChannelPacket(WorldPacket * packet, uint8 status);

	//SMSS_CenterMatch_MatchStage = 0x2721,						//比赛进度
	bool CreateCenterMatchStageInofPacket(WorldPacket * packet, CenterMatchLogic * cml);

	//SMSS_CenterMatch_JoinChannelNotify = 0x2723,						//通知进入牌桌
	bool CreateCenterMatchJoinChannelNotifyPacket(WorldPacket * packet, const uint32 & channel_id);

	//SMSS_CenterMatch_JoinChannel = 0x2724,						//进入牌桌
	bool CreateCenterMatchJoinChannelPacket(WorldPacket * packet, const uint32 & channel_id, const uint8 result);

	//SMSS_CenterMatch_RiseOrDown = 0x2725,						//晋级or淘汰
	bool CreateCenterMatchRiseOrDownNotifyPacket(WorldPacket * packet, const uint16 & now_rank,const uint16 & now_playerNum, const uint32 & now_channel,std::map<uint32,uint32> prize,String str, uint8 result);

	//SMSS_CenterMatch_MatchEnd = 0x2726,						//比赛结束
	
	// SMSG_REQUIE_MATCHZONELIST = 0x2740,						// 请求赛区列表
	bool CreateCenterMatchZoneListPacket(WorldPacket * packet, std::map<uint32, stMatchZone> mapMz);
	
#endif // CENTERMATCH

#ifdef PKPUBLIC
/* -----------------------------------扑克相关协议---------------------------------------- */
	// SMSG_PUKE_PlayerInfo = 0x3000    玩家信息
	bool CreatePKPlayerInfoPacket(WorldPacket * packet, PKBaseTablePlayer * Player);
	// SMSG_PUKE_PlayerDoList = 0x3001 	玩家可操作列表
	bool CreatePKPlayerOperatorListPacket(WorldPacket * packet,std::map<uint32,OperatorList> DoList);
	// SMSG_PUKE_PlayerDoResult = 0x3002,						// 玩家操作结果
	bool CreatePKPlayerOperatorResultPacket(WorldPacket * packet, const uint8 & model , bool result);
	// SMSG_PUKE_PlayerCards = 0x3003,							// 玩家牌信息
	bool CreatePKPlayerCardsInfoPacket(WorldPacket * packet, const uint8 & pos, const uint8 & cscnum, const uint8 & cardtype, const uint32 & cardpoint,std::vector<uint16> cards, const uint8 & operatortype);
	// SMSG_PUKE_PlayerChipin = 0x3004,						// 玩家下注总金额
	bool CreatePKPlayerChipinInfoPacket(WorldPacket * packet, std::vector<PKBaseTablePlayer> Player);
	// SMSG_PUKE_PlayerStartStatus = 0x3005,					// 玩家游戏中状态
	bool CreatePKPlayerStartStatusPacket(WorldPacket * packet, const uint8 & pos, const int & chipin, const uint8 & type);
	// SMSG_PUKE_GameCalc = 0x3006,							// 游戏结算信息包
	bool CreatePKSendGameCalcPacket(WorldPacket * packet,std::vector<PKBaseTablePlayer> player, PKBaseTablePlayer & pTp, bool result);
#endif

	//-=-=-=-=-=-=-=-=-=-=-=-比赛相关end===========================================

protected:
	/**
	 * @创建时间 2011-09-01
	 * @创建人 李志勇
	 * @函数作用 只下发协议或者附带状态的封包
	 * @参数
	 * 	@protocol 协议
	 * 	@status 状态
	 */
	bool CreateReturnStatePacket(WorldPacket * packet, const uint16 protocol, const uint8 status = 0);
	/**
	 * @创建时间 2011-12-22
	 * @创建人 李志勇
	 * @函数作用 获取物品的文字字段数据, 物品自身有数据就用自身的，否则用模式表相同字段数据
	 * @参数
	 * 	@itemPtr 物品
	 * 	@fieldName 字段明
	 */
	String GetItemText(ItemPtr &itemPtr, const char* fieldName);
	/**
	 * @创建时间 2012-03-02
	 * @创建人 李志勇
	 * @函数作用 只下发协议的封包
	 * @参数
	 * 	@protocol 协议
	 */
	bool CreateSimplePacket(WorldPacket * packet, const uint16 protocol);
	
};


#endif
